1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect.testing;
18
19 import com.google.common.collect.testing.features.CollectionFeature;
20 import com.google.common.collect.testing.features.CollectionSize;
21 import com.google.common.collect.testing.features.SetFeature;
22
23 import junit.framework.Test;
24 import junit.framework.TestSuite;
25
26 import java.io.Serializable;
27 import java.lang.reflect.Method;
28 import java.util.AbstractSet;
29 import java.util.Collection;
30 import java.util.Collections;
31 import java.util.Comparator;
32 import java.util.EnumSet;
33 import java.util.HashSet;
34 import java.util.Iterator;
35 import java.util.LinkedHashSet;
36 import java.util.Set;
37 import java.util.SortedSet;
38 import java.util.TreeSet;
39 import java.util.concurrent.ConcurrentSkipListSet;
40 import java.util.concurrent.CopyOnWriteArraySet;
41
42
43
44
45
46
47
48
49 public class TestsForSetsInJavaUtil {
50 public static Test suite() {
51 return new TestsForSetsInJavaUtil().allTests();
52 }
53
54 public Test allTests() {
55 TestSuite suite = new TestSuite("java.util Sets");
56 suite.addTest(testsForEmptySet());
57 suite.addTest(testsForSingletonSet());
58 suite.addTest(testsForHashSet());
59 suite.addTest(testsForLinkedHashSet());
60 suite.addTest(testsForEnumSet());
61 suite.addTest(testsForTreeSetNatural());
62 suite.addTest(testsForTreeSetWithComparator());
63 suite.addTest(testsForCopyOnWriteArraySet());
64 suite.addTest(testsForUnmodifiableSet());
65 suite.addTest(testsForCheckedSet());
66 suite.addTest(testsForAbstractSet());
67 suite.addTest(testsForBadlyCollidingHashSet());
68 suite.addTest(testsForConcurrentSkipListSetNatural());
69 suite.addTest(testsForConcurrentSkipListSetWithComparator());
70
71 return suite;
72 }
73
74 protected Collection<Method> suppressForEmptySet() {
75 return Collections.emptySet();
76 }
77 protected Collection<Method> suppressForSingletonSet() {
78 return Collections.emptySet();
79 }
80 protected Collection<Method> suppressForHashSet() {
81 return Collections.emptySet();
82 }
83 protected Collection<Method> suppressForLinkedHashSet() {
84 return Collections.emptySet();
85 }
86 protected Collection<Method> suppressForEnumSet() {
87 return Collections.emptySet();
88 }
89 protected Collection<Method> suppressForTreeSetNatural() {
90 return Collections.emptySet();
91 }
92 protected Collection<Method> suppressForTreeSetWithComparator() {
93 return Collections.emptySet();
94 }
95 protected Collection<Method> suppressForCopyOnWriteArraySet() {
96 return Collections.emptySet();
97 }
98 protected Collection<Method> suppressForUnmodifiableSet() {
99 return Collections.emptySet();
100 }
101 protected Collection<Method> suppressForCheckedSet() {
102 return Collections.emptySet();
103 }
104 protected Collection<Method> suppressForAbstractSet() {
105 return Collections.emptySet();
106 }
107 protected Collection<Method> suppressForConcurrentSkipListSetNatural() {
108 return Collections.emptySet();
109 }
110 protected Collection<Method> suppressForConcurrentSkipListSetWithComparator() {
111 return Collections.emptySet();
112 }
113
114 public Test testsForEmptySet() {
115 return SetTestSuiteBuilder
116 .using(new TestStringSetGenerator() {
117 @Override public Set<String> create(String[] elements) {
118 return Collections.emptySet();
119 }
120 })
121 .named("emptySet")
122 .withFeatures(
123 CollectionFeature.SERIALIZABLE,
124 CollectionSize.ZERO)
125 .suppressing(suppressForEmptySet())
126 .createTestSuite();
127 }
128
129 public Test testsForSingletonSet() {
130 return SetTestSuiteBuilder
131 .using(new TestStringSetGenerator() {
132 @Override public Set<String> create(String[] elements) {
133 return Collections.singleton(elements[0]);
134 }
135 })
136 .named("singleton")
137 .withFeatures(
138 CollectionFeature.SERIALIZABLE,
139 CollectionFeature.ALLOWS_NULL_VALUES,
140 CollectionSize.ONE)
141 .suppressing(suppressForSingletonSet())
142 .createTestSuite();
143 }
144
145 public Test testsForHashSet() {
146 return SetTestSuiteBuilder
147 .using(new TestStringSetGenerator() {
148 @Override public Set<String> create(String[] elements) {
149 return new HashSet<String>(MinimalCollection.of(elements));
150 }
151 })
152 .named("HashSet")
153 .withFeatures(
154 SetFeature.GENERAL_PURPOSE,
155 CollectionFeature.SERIALIZABLE,
156 CollectionFeature.ALLOWS_NULL_VALUES,
157 CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
158 CollectionSize.ANY)
159 .suppressing(suppressForHashSet())
160 .createTestSuite();
161 }
162
163 public Test testsForLinkedHashSet() {
164 return SetTestSuiteBuilder
165 .using(new TestStringSetGenerator() {
166 @Override public Set<String> create(String[] elements) {
167 return new LinkedHashSet<String>(MinimalCollection.of(elements));
168 }
169 })
170 .named("LinkedHashSet")
171 .withFeatures(
172 SetFeature.GENERAL_PURPOSE,
173 CollectionFeature.SERIALIZABLE,
174 CollectionFeature.ALLOWS_NULL_VALUES,
175 CollectionFeature.KNOWN_ORDER,
176 CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
177 CollectionSize.ANY)
178 .suppressing(suppressForLinkedHashSet())
179 .createTestSuite();
180 }
181
182 public Test testsForEnumSet() {
183 return SetTestSuiteBuilder
184 .using(new TestEnumSetGenerator() {
185 @Override public Set<AnEnum> create(AnEnum[] elements) {
186 return (elements.length == 0)
187 ? EnumSet.noneOf(AnEnum.class)
188 : EnumSet.copyOf(MinimalCollection.of(elements));
189 }
190 })
191 .named("EnumSet")
192 .withFeatures(
193 SetFeature.GENERAL_PURPOSE,
194 CollectionFeature.SERIALIZABLE,
195 CollectionFeature.KNOWN_ORDER,
196 CollectionFeature.RESTRICTS_ELEMENTS,
197 CollectionSize.ANY)
198 .suppressing(suppressForEnumSet())
199 .createTestSuite();
200 }
201
202 public Test testsForTreeSetNatural() {
203 return NavigableSetTestSuiteBuilder
204 .using(new TestStringSortedSetGenerator() {
205 @Override public SortedSet<String> create(String[] elements) {
206 return new TreeSet<String>(MinimalCollection.of(elements));
207 }
208 })
209 .named("TreeSet, natural")
210 .withFeatures(
211 SetFeature.GENERAL_PURPOSE,
212 CollectionFeature.SERIALIZABLE,
213 CollectionFeature.KNOWN_ORDER,
214 CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
215 CollectionSize.ANY)
216 .suppressing(suppressForTreeSetNatural())
217 .createTestSuite();
218 }
219
220 public Test testsForTreeSetWithComparator() {
221 return NavigableSetTestSuiteBuilder
222 .using(new TestStringSortedSetGenerator() {
223 @Override public SortedSet<String> create(String[] elements) {
224 SortedSet<String> set
225 = new TreeSet<String>(arbitraryNullFriendlyComparator());
226 Collections.addAll(set, elements);
227 return set;
228 }
229 })
230 .named("TreeSet, with comparator")
231 .withFeatures(
232 SetFeature.GENERAL_PURPOSE,
233 CollectionFeature.SERIALIZABLE,
234 CollectionFeature.ALLOWS_NULL_VALUES,
235 CollectionFeature.KNOWN_ORDER,
236 CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
237 CollectionSize.ANY)
238 .suppressing(suppressForTreeSetWithComparator())
239 .createTestSuite();
240 }
241
242 public Test testsForCopyOnWriteArraySet() {
243 return SetTestSuiteBuilder
244 .using(new TestStringSetGenerator() {
245 @Override public Set<String> create(String[] elements) {
246 return new CopyOnWriteArraySet<String>(
247 MinimalCollection.of(elements));
248 }
249 })
250 .named("CopyOnWriteArraySet")
251 .withFeatures(
252 CollectionFeature.SUPPORTS_ADD,
253 CollectionFeature.SUPPORTS_REMOVE,
254 CollectionFeature.SERIALIZABLE,
255 CollectionFeature.ALLOWS_NULL_VALUES,
256 CollectionFeature.KNOWN_ORDER,
257 CollectionSize.ANY)
258 .suppressing(suppressForCopyOnWriteArraySet())
259 .createTestSuite();
260 }
261
262 public Test testsForUnmodifiableSet() {
263 return SetTestSuiteBuilder
264 .using(new TestStringSetGenerator() {
265 @Override public Set<String> create(String[] elements) {
266 Set<String> innerSet = new HashSet<String>();
267 Collections.addAll(innerSet, elements);
268 return Collections.unmodifiableSet(innerSet);
269 }
270 })
271 .named("unmodifiableSet/HashSet")
272 .withFeatures(
273 CollectionFeature.NONE,
274 CollectionFeature.SERIALIZABLE,
275 CollectionFeature.ALLOWS_NULL_VALUES,
276 CollectionSize.ANY)
277 .suppressing(suppressForUnmodifiableSet())
278 .createTestSuite();
279 }
280
281 public Test testsForCheckedSet() {
282 return SetTestSuiteBuilder
283 .using(new TestStringSetGenerator() {
284 @Override public Set<String> create(String[] elements) {
285 Set<String> innerSet = new HashSet<String>();
286 Collections.addAll(innerSet, elements);
287 return Collections.checkedSet(innerSet, String.class);
288 }
289 })
290 .named("checkedSet/HashSet")
291 .withFeatures(
292 SetFeature.GENERAL_PURPOSE,
293 CollectionFeature.SERIALIZABLE,
294 CollectionFeature.ALLOWS_NULL_VALUES,
295 CollectionFeature.RESTRICTS_ELEMENTS,
296 CollectionSize.ANY)
297 .suppressing(suppressForCheckedSet())
298 .createTestSuite();
299 }
300
301 public Test testsForAbstractSet() {
302 return SetTestSuiteBuilder
303 .using(new TestStringSetGenerator () {
304 @Override protected Set<String> create(String[] elements) {
305 final String[] deduped = dedupe(elements);
306 return new AbstractSet<String>() {
307 @Override public int size() {
308 return deduped.length;
309 }
310 @Override public Iterator<String> iterator() {
311 return MinimalCollection.of(deduped).iterator();
312 }
313 };
314 }
315 })
316 .named("AbstractSet")
317 .withFeatures(
318 CollectionFeature.NONE,
319 CollectionFeature.ALLOWS_NULL_VALUES,
320 CollectionFeature.KNOWN_ORDER,
321 CollectionSize.ANY)
322 .suppressing(suppressForAbstractSet())
323 .createTestSuite();
324 }
325
326 public Test testsForBadlyCollidingHashSet() {
327 return SetTestSuiteBuilder
328 .using(new TestCollidingSetGenerator() {
329 @Override
330 public Set<Object> create(Object... elements) {
331 return new HashSet<Object>(MinimalCollection.of(elements));
332 }
333 })
334 .named("badly colliding HashSet")
335 .withFeatures(
336 SetFeature.GENERAL_PURPOSE,
337 CollectionFeature.ALLOWS_NULL_VALUES,
338 CollectionSize.SEVERAL)
339 .suppressing(suppressForHashSet())
340 .createTestSuite();
341 }
342
343 public Test testsForConcurrentSkipListSetNatural() {
344 return SetTestSuiteBuilder
345 .using(new TestStringSortedSetGenerator() {
346 @Override public SortedSet<String> create(String[] elements) {
347 return new ConcurrentSkipListSet<String>(MinimalCollection.of(elements));
348 }
349 })
350 .named("ConcurrentSkipListSet, natural")
351 .withFeatures(
352 SetFeature.GENERAL_PURPOSE,
353 CollectionFeature.SERIALIZABLE,
354 CollectionFeature.KNOWN_ORDER,
355 CollectionSize.ANY)
356 .suppressing(suppressForConcurrentSkipListSetNatural())
357 .createTestSuite();
358 }
359
360 public Test testsForConcurrentSkipListSetWithComparator() {
361 return SetTestSuiteBuilder
362 .using(new TestStringSortedSetGenerator() {
363 @Override public SortedSet<String> create(String[] elements) {
364 SortedSet<String> set
365 = new ConcurrentSkipListSet<String>(arbitraryNullFriendlyComparator());
366 Collections.addAll(set, elements);
367 return set;
368 }
369 })
370 .named("ConcurrentSkipListSet, with comparator")
371 .withFeatures(
372 SetFeature.GENERAL_PURPOSE,
373 CollectionFeature.SERIALIZABLE,
374 CollectionFeature.KNOWN_ORDER,
375 CollectionSize.ANY)
376 .suppressing(suppressForConcurrentSkipListSetWithComparator())
377 .createTestSuite();
378 }
379
380 private static String[] dedupe(String[] elements) {
381 Set<String> tmp = new LinkedHashSet<String>();
382 Collections.addAll(tmp, elements);
383 return tmp.toArray(new String[0]);
384 }
385
386 static <T> Comparator<T> arbitraryNullFriendlyComparator() {
387 return new NullFriendlyComparator<T>();
388 }
389
390 private static final class NullFriendlyComparator<T>
391 implements Comparator<T>, Serializable {
392 @Override
393 public int compare(T left, T right) {
394 return String.valueOf(left).compareTo(String.valueOf(right));
395 }
396 }
397 }